﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
//给你一个整数数组 nums ，请计算数组的 中心下标 。
//数组 中心下标 是数组的一个下标，其左侧所有元素相加的和等于右侧所有元素相加的和。
//如果中心下标位于数组最左端，那么左侧数之和视为 0 ，因为在下标的左侧不存在元素。这一点对于中心下标位于数组最右端同样适用。
//如果数组有多个中心下标，应该返回 最靠近左边 的那一个。如果数组不存在中心下标，返回 - 1 。
//力扣题，稍微整理一下，就将代码变得更直观。
//int Addleft(int* nums, int i)
//{
//	int sum = 0;
//	int x = 0;
//	for (x = 0; x < i; x++)
//	{
//		sum += nums[x];
//	}
//	return sum;
//}
//int Addright(int* nums, int i, int numsSize)
//{
//	int sum = 0;
//	for (++i; i < numsSize; i++)
//	{
//		sum += nums[i];
//	}
//	return sum;
//}
//
//int pivotIndex(int* nums, int numsSize)
//{
//	int left = 0;
//	int right = 0;
//	int i = 0;
//	for (i = 0; i < numsSize; i++)
//	{
//		right = Addright(nums, i, numsSize);
//		left = Addleft(nums, i);
//		if (right == left)
//		{
//			return i;
//		}
//	}
//	return -1;
//}
//
//int main()
//{
//	int nums[] = { 1,7,3,6,5,6 };
//	int sz = sizeof(nums) / sizeof(nums[0]);
//	pivotIndex(nums, sz);
//	return 0;
//}

//给你一个整数数组 nums ，另给你一个整数 original ，这是需要在 nums 中搜索的第一个数字。
//接下来，你需要按下述步骤操作：
//如果在 nums 中找到 original ，将 original 乘以 2 ，得到新 original（即，令 original = 2 * original）。
//否则，停止这一过程。
//只要能在数组中找到新 original ，就对新 original 继续 重复 这一过程。
//返回 original 的 最终 值。
//将代码量给减少了，效率也提上去了
//int findFinalValue(int* nums, int numsSize, int original)
//{
//	int i = 0;
//	for (i = 0; i < numsSize; i++)
//	{
//		if (nums[i] == original)
//		{
//			i = -1;
//			original *= 2;
//		}
//	}
//	return original;
//}
//int main()
//{
//	int arr[] = { 8,19,4,2,15,3 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int n = 2;
//	findFinalValue(arr, sz, n);
//	return 0;
//}

//给你一个仅包含小写英文字母和 '?' 字符的字符串 s，请你将所有的 '?' 转换为若干小写字母，使最终的字符串不包含任何 连续重复 的字符。
//注意：你 不能 修改非 '?' 字符。
//题目测试用例保证 除 '?' 字符 之外，不存在连续重复的字符。
//在完成所有转换（可能无需转换）后返回最终的字符串。如果有多个解决方案，请返回其中任何一个。
//可以证明，在给定的约束条件下，答案总是存在的。
// 上次是看别人的，这次自己写的，代码量变大了
//char test1(char* ch, int sz, char p)
//{
//	for (int i = 0; i < sz; i++)
//	{
//		if (ch[i] != p)
//		{
//			return ch[i];
//		}
//	}
//	return 0;
//}
//
//char test2(char* ch, int sz, char p, char s)
//{
//	for (int i = 0; i < sz; i++)
//	{
//		if (ch[i] != p && ch[i] != s)
//		{
//			return ch[i];
//		}
//	}
//	return 0;
//}
//
//char* modifyString(char* s)
//{
//	int i = 0;
//	int len = strlen(s);
//	char ch[27] = "abcdefghijklmnopqrstuvwxyz";
//	if (*s == '?')
//	{
//		if (*(s + 1) != '?')
//		{
//			*s = test1(ch, 26, *(s + 1));
//		}
//		else
//			*s = 'a';
//	}
//	if (*(s + len - 1) == '?')
//	{
//		if (*(s + len - 2) != '?')
//		{
//			*(s + len - 1) = test1(ch, 26, *(s + len - 2));
//		}
//		else
//			*(s + len - 1) = 'a';
//	}
//	for (i = 1; i < len - 1; i++)
//	{
//		if (s[i] == '?')
//		{
//			s[i] = test2(ch, 26, s[i - 1], s[i + 1]);
//		}
//	}
//	return s;
//}
//int main()
//{
//	char p[] = "j?qg??b";
//	modifyString(p);
//	return 0;
//}

//重写了一遍，写完后和原来一样
//int* smallerNumbersThanCurrent(int* nums, int numsSize, int* returnSize)
//{
//	*returnSize = numsSize;
//	int* returns = (int*)malloc(sizeof(int) * numsSize);
//	for (int i = 0; i < numsSize; i++)
//	{
//		int amount = 0;
//		for (int j = 0; j < numsSize; j++)
//		{
//			if (j == i)
//			{
//				continue;
//			}
//			else
//			{
//				if (nums[i] < nums[j])
//				{
//					amount++;
//				}
//			}
//		}
//		returns[i] = amount;
//	}
//	return returns;
//}

//有一堆石头，每块石头的重量都是正整数。
//每一回合，从中选出两块 最重的 石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
//如果 x == y，那么两块石头都会被完全粉碎；
//如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y - x。
//最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。
//int cmpfunc(const void* a, const void* b)
//{
//	return (*(int*)b - *(int*)a);
//}
//
//int lastStoneWeight(int* stones, int stonesSize) {
//	if (stonesSize == 1)
//	{
//		return stones[0];
//	}
//	while (1)
//	{
//		qsort(stones, stonesSize, sizeof(int), cmpfunc);
//		if (stones[1] == 0)
//		{
//			break;
//		}
//		else
//		{
//			if (stones[0] == stones[1])
//			{
//				stones[0] = 0;
//				stones[1] = 0;
//			}
//			else
//			{
//				stones[0] -= stones[1];
//				stones[1] = 0;
//			}
//		}
//	}
//	return stones[0];
//}

//通过用例，但是效率低下
//int cmpfunc(const void* a, const void* b)
//{
//	return (*(int*)a - *(int*)b);
//}
//
//int largestSumAfterKNegations(int* nums, int numsSize, int k) {
//	while (k)
//	{
//		qsort(nums, numsSize, sizeof(int), cmpfunc);
//		nums[0] = -nums[0];
//		k--;
//	}
//	int sum = 0;
//	for (int i = 0; i < numsSize; i++)
//	{
//		sum += nums[i];
//	}
//	return sum;
//}
//int main()
//{
//	int arr[] = { 2,-3,-1,5,-4 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	largestSumAfterKNegations(arr, sz, 2);
//	return 0;
//}

//如果数组是单调递增或单调递减的，那么它是 单调 的。
//如果对于所有 i <= j，nums[i] <= nums[j]，那么数组 nums 是单调递增的。 
//如果对于所有 i <= j，nums[i] > = nums[j]，那么数组 nums 是单调递减的。
//当给定的数组 nums 是单调数组时返回 true，否则返回 false。
//bool isMonotonic(int* nums, int numsSize) {
//	int i = 0;
//	if (nums[0] - nums[numsSize] >= 0)
//	{
//		for (i = 0; i < numsSize - 1; i++)
//		{
//			if (nums[i] - nums[i + 1] < 0)
//				return false;
//		}
//	}
//	else
//	{
//		for (i = 0; i < numsSize - 1; i++)
//		{
//			if (nums[i] - nums[i + 1] > 0)
//				return false;
//		}
//	}
//	return true;
//}

//给你一个整数数组 nums ，该数组具有以下属性：
//nums.length == 2 * n.
//nums 包含 n + 1 个 不同的 元素
//nums 中恰有一个元素重复 n 次
//找出并返回重复了 n 次的那个元素。
//int repeatedNTimes(int* nums, int numsSize)
//{
//	int i = 0;
//	for (i = 0; i < numsSize; i++)
//	{
//		int j = 0;
//		for (j = 0; j < numsSize; j++)
//		{
//			if (j == i)
//			{
//				continue;
//			}
//			else
//			{
//				if (nums[i] == nums[j])
//					goto end;
//			}
//		}
//	}
//end:
//	return nums[i];
//}

//
//int cmpfunc(const void* a, const void* b)
//{
//	return (*(int*)a - *(int*)b);
//}
//
//int* sortedSquares(int* nums, int numsSize, int* returnSize) {
//	*returnSize = numsSize;
//	int* returns = (int*)malloc(sizeof(int) * numsSize);
//	int i = 0;
//	for (i = 0; i < numsSize; i++)
//	{
//		returns[i] = nums[i] * nums[i];
//	}
//	//qsort(returns, *returnSize, sizeof(int), cmpfunc);
//	for (i = 0; i < numsSize - 1; i++)
//	{
//		int j = 0;
//		for (j = i + 1; j < numsSize; j++)
//		{
//			if (returns[i] > returns[j])
//			{
//				int tmp = returns[i];
//				returns[i] = returns[j];
//				returns[j] = tmp;
//			}
//		}
//	}
//	return returns;
//}
//int main()
//{
//	int arr[] = { -4,-1,0,3,10 };
//	int sz = sizeof(arr) / sizeof(arr[0]);
//	int n = 0;
//	int* arr1 = sortedSquares(arr, sz, &n);
//	int i = 0;
//	for (i = 0; i < n; i++)
//	{
//		printf("%d ", arr1[i]);
//	}
//	return 0;
//}

//给你两个非负整数 low 和 high 。请你返回 low 和 high 之间（包括二者）奇数的数目。
//int countOdds(int low, int high) {
//    int amount = 0;
//    if (low % 2 == 0 && high % 2 == 0)
//    {
//        amount = (high - low) / 2;
//    }
//    else
//    {
//        amount = (high - low) / 2 + 1;
//    }
//    return amount;
//}

